
"""
    1，创建一个 3x3 并且值从0到8的矩阵
    2，创建一个 10x10 的随机数组并找到它的最大值和最小值提示：可以使用np.random.random((10,10))创建随机数组
    3，一个5x3的矩阵与一个3x2的矩阵相乘，矩阵乘积是什么？
    4，创建一个长度为10，并且除了第五个值为1，其他值均为0的一维数组。



"""

import os
import logging
import numpy as np

class Practice0812:

    def __init__(self  , *args):
        self.filePath = args[0]
        self.total_count = args[1]
        self.content_count = args[2]



    def create_arithmetic_sequence(self):
        # 1，创建一个 3x3 并且值从0到8的矩阵
        # 第一种方式，等差数列  大小 1- 100 的数 100个元素
        # start ：起始值
        # stop：结束值（包含）
        # num：元素个数
        matrix = np.linspace(start=0, stop=8, num=9)
        self.arithmetic_sequence_info('matrix', matrix)
        # 改变维度 产生一个新的数组，重新设置形状（10行、10列）
        matrix_new = matrix.reshape(3, 3)  # 3 *3 = 9
        self.arithmetic_sequence_info('matrix_new', matrix_new)
        #第二种方式生成  3x3 并且值从0到8的矩阵
        my_matrix = np.arange(9).reshape(3, 3)
        self.arithmetic_sequence_info('my_matrix', my_matrix)

    def create_arithmetic_sequence2(self):
        # 2，创建一个 10x10 的随机数组并找到它的最大值和最小值提示：可以使用np.random.random((10,10))创建随机数组
        matrix = np.random.random((10, 10))
        self.arithmetic_sequence_info('matrix', matrix)
        print(f'np.max(matrix)={np.max(matrix)}')
        print(f'np.min(matrix)={np.min(matrix)}')

    def create_arithmetic_sequence3(self):
        #3，一个5x3的矩阵与一个3x2的矩阵相乘，矩阵乘积是什么？
        # 生成一个一维序列数组
        tmp_array1 = np.linspace(start=1, stop=15, num=15)
        # 修改tmp_array的形状，生成的形状也是5行3列
        matrix_new1 = tmp_array1.reshape(5, 3)
        self.arithmetic_sequence_info('matrix_new1', matrix_new1)

        # 生成一个一维序列数组
        tmp_array2 = np.linspace(start=1, stop=6, num=6)
        # 修改tmp_array的形状，生成的形状也是3行2列
        matrix_new2 = tmp_array2.reshape(3, 2)
        self.arithmetic_sequence_info('matrix_new2', matrix_new2)

        self.arithmetic_sequence_info('内积运算 dot(matrix_new1 , matrix_new2)', np.dot(matrix_new1 , matrix_new2))
        self.arithmetic_sequence_info('内积运算 (matrix_new1 @ matrix_new2)', matrix_new1 @ matrix_new2)

        # 第二种方式生成随机矩阵 一个5x3的矩阵与一个3x2的矩阵相乘  (5,3)与(3,2)矩阵相乘得(5，2)矩阵
        matrix1 = np.random.rand(5,3)
        matrix2 = np.random.rand(3,2)
        self.arithmetic_sequence_info('内积运算 dot(matrix1 , matrix2)', np.dot(matrix1, matrix2))
        self.arithmetic_sequence_info('内积运算 (matrix1 @ matrix2)', matrix1 @ matrix2)

    def create_arithmetic_sequence4(self):
        #4，创建一个长度为10，并且除了第五个值为1，其他值均为0的一维数组。
        # 创建一个长度为10的列表，所有元素初始化为0
        tmp_array = [0] * 10
        # 将第五个元素（索引为4，因为索引从0开始）的值改为1
        tmp_array[4] = 1
        self.arithmetic_sequence_info('tmp_array', tmp_array)

        my_array = np.zeros(10)
        my_array[4] = 1
        self.arithmetic_sequence_info('my_array', my_array)

    def create_other(self):

        # 1、第一种通过数组创建等差数列
        np_tmp_array = np.array([1, 2, 3, 4])
        self.arithmetic_sequence_info('np_tmp_array' , np_tmp_array)
        print('*' * 30)
        # 2、第二种方式，等差数列  大小 1- 100 的数 10个元素
        np_tmp = np.linspace(1, 100, 10)
        self.arithmetic_sequence_info('np_tmp' , np_tmp)
        print('*' * 30)
        # 3、第三种方式，等差数列，1-100（不包括结束） , 最后一个参数是步长 step
        np_tmp = np.arange(1 , 100 ,3)
        self.arithmetic_sequence_info('np_tmp' ,np_tmp)

        print('*' * 20)
        np_tmp = np.arange(9)
        self.arithmetic_sequence_info('np_tmp', np_tmp)

        print('*' * 30)



        # 4、第四种 生成值全为1的数组
        np_tmp = np.ones(shape=(3, 5))  # 3行5列
        self.arithmetic_sequence_info('np_tmp' ,np_tmp)
        print('*' * 30)

        # 5、第五种，生成值全为0的数组
        np_tmp = np.zeros(10)  # 可以不指定形状
        self.arithmetic_sequence_info('np.zeros(10).np_tmp', np_tmp)
        print('*' * 20)
        np_tmp = np.zeros(shape=(2, 3))  # 2行3列
        self.arithmetic_sequence_info(' np.zeros(shape=(2, 3)).np_tmp' ,np_tmp)
        print('*' * 30)

        #生成一个一维序列数组
        tmp_array = np.linspace(start=1, stop=100, num=100)
        # 修改tmp_array的形状，生成的形状也是10行10列
        matrix_new = tmp_array.reshape(10, 10)

        # 6、第六种，可以按照某个已经存在的等差数列生成
        # 按照tmp_array的形状生成 全为1的数组
        np_tmp = np.ones_like(tmp_array)
        self.arithmetic_sequence_info('ones_like_arry' ,np_tmp)
        print('全为1的数组:' + '*' * 10)

        # matrix_new的形状是10行、10列 ，生成的形状也是10行10列（元素全是1）
        np_tmp = np.ones_like(matrix_new)
        self.arithmetic_sequence_info('ones_like_matrix' ,np_tmp)
        print('*' * 30)

        # 7、第七种，按照matrix_new生成值全为0的数组
        # 按照tmp_array的形状生成 全为0的数组
        np_tmp = np.zeros_like(tmp_array)
        self.arithmetic_sequence_info('zeros_like_array' ,np_tmp)
        print('全为0的数组:' +'*' * 10)
        np_tmp = np.zeros_like(matrix_new)
        self.arithmetic_sequence_info('zeros_like_matrix' , np_tmp)
        print('*' * 30)

        # 8、第八种 对角矩阵, 根据 x2的形状（10*10）生成对角矩阵
            ##对角矩阵 ，除了主对角线 ，其它全为0 的数组
        np_tmp = np.diag(tmp_array) #把数组种所有的元素作为对角矩阵中的元素，导致矩阵 100 * 100
        self.arithmetic_sequence_info('diag_array' , np_tmp)
        np_tmp = np.diag(matrix_new)  # 只打印 对角矩阵不为0的元素
        self.arithmetic_sequence_info('diag_matrix_new', np_tmp)
        print('*' * 30)

        # 9、第九种 单位矩阵  主对角线的元素为1，其它元素全为0
        np_tmp = np.eye(4)  # 生成 4*4的单位矩阵
        self.arithmetic_sequence_info('eye', np_tmp)
        print('*' * 30)

        #10、矩阵拼接
        # 生成一个一维序列数组
        tmp_array1 = np.linspace(start=1, stop=6, num=6)
        # 修改tmp_array的形状，生成的形状也是2行3列
        matrix_new1 = tmp_array1.reshape(2, 3)
        self.arithmetic_sequence_info('matrix_new1', matrix_new1)

        # 生成一个一维序列数组
        tmp_array2 = np.linspace(start=1, stop=4, num=4)
        # 修改tmp_array的形状，生成的形状也是2行2列
        matrix_new2 = tmp_array2.reshape(2, 2)
        self.arithmetic_sequence_info('matrix_new2', matrix_new2)

        # 按列的顺序（列增加，行不变），堆叠数组构成一个新的数组
        #  2 * 3  + 2 * 2  = 2 * 5
        matrix_new3 = np.hstack((matrix_new1, matrix_new2))  #
        self.arithmetic_sequence_info('matrix_new3', matrix_new3)



    def arithmetic_sequence_info(self , name , arithmetic_sequence):

        print(f"等差数列{name},shape={arithmetic_sequence.shape if hasattr(arithmetic_sequence , 'shape') else '无'}：")
        print(arithmetic_sequence)
        print(f'元素个数：{arithmetic_sequence.size if hasattr(arithmetic_sequence , 'size') else len(arithmetic_sequence)}')  # 元素个数
        print(f'查看维度：{arithmetic_sequence.ndim  if hasattr(arithmetic_sequence , 'ndim') else '无'}')  # 查看维度


    def print_array2_slice(self):
        #二维数组切片
        # 2、第二种方式，等差数列  大小 1- 100 的数 10个元素
        tmp_array = np.linspace(1, 20, 9)
        # 修改tmp_array的形状，生成的形状也是10行10列
        matrix_new = tmp_array.reshape(3, 3)
        self.arithmetic_sequence_info('np_tmp', matrix_new)
        # 二维数组切片是切行索引
        # data[行切开始:行切结束 , 列切开始:列切结束]
        # 第一个参数：行开始索引，默认0从开始索引
        # 第二个参数：行结束索引（不包括结束），默认到最后，逗号后面的是列索引#二维数组切片是切行索引
        #如：data[:, 0]，切片从第0行开始（不给默认） 到最后一行结束（不给默认），每行只取第1列的元素

        #取第一行 第二列的单元格
        print(f'matrix_new[0,1] = {matrix_new[0,1]}')
        #取第一列的元素（所有行号的第一列元素）
        print(f'matrix_new[:,0] = {matrix_new[:,0]}')
        # 所有行号的第一列和第二列元素）
        print(f'matrix_new[:,0:2] = {matrix_new[:,0:2]}')
        # 所有行号的第二列
        print(f'matrix_new[:,1:2] = {matrix_new[:, 1:2]}')
        # 取第二行的，第一列、第二列的元素
        print(f'matrix_new[1:2,0:2] = {matrix_new[1:2, 0:2]}')


    def cal_array2(self):
        #二维数组运算 #两个数组之间做加减乘除运算 形状必须一致
        ## + - *  **  / %
        # 生成一个一维序列数组
        tmp_array1 = np.linspace(start=1, stop=4, num=4)
        self.arithmetic_sequence_info('tmp_array1', tmp_array1)
        tmp_array = tmp_array1 + 1
        self.arithmetic_sequence_info('tmp_array1 + 1=', tmp_array)
        tmp_array = tmp_array1 * 3
        self.arithmetic_sequence_info('tmp_array1 * 3=', tmp_array)
        tmp_array = tmp_array1 ** 2
        self.arithmetic_sequence_info('tmp_array1 ** 2=', tmp_array)
        print('*' * 20)

        #修改tmp_array的形状，生成的形状也是2行2列
        matrix_new1 = tmp_array1.reshape(2, 2)
        self.arithmetic_sequence_info('matrix_new1', matrix_new1)

        # 生成一个一维序列数组
        tmp_array2 = np.linspace(start=1, stop=4, num=4)
        # 修改tmp_array的形状，生成的形状也是2行2列
        matrix_new2 = tmp_array2.reshape(2, 2)
        self.arithmetic_sequence_info(' matrix_new2', matrix_new2)
        # 乘积运算matrix_new1 * matrix_new2，如果形状不一致会报错：ValueError: operands could not be broadcast together with shapes (5,3) (3,2)
        # 两个数组之间做加减乘除运算 形状必须一致
        matrix_new = matrix_new1 * matrix_new2
        self.arithmetic_sequence_info('乘积运算matrix_new1 * matrix_new2', matrix_new)
        matrix_new = matrix_new1 / matrix_new2
        self.arithmetic_sequence_info('除数运算 matrix_new1 / matrix_new2', matrix_new)
        matrix_new = matrix_new1 // matrix_new2
        self.arithmetic_sequence_info('除数取整运算 matrix_new1 // matrix_new2', matrix_new)
        matrix_new = matrix_new1 % matrix_new2
        self.arithmetic_sequence_info('取模运算 matrix_new1 % matrix_new2', matrix_new)
        # 内积运算  #注意：内积运算 arr1的列数一定要等于arr2的行 m * n,  n * t
        matrix_new = matrix_new1 @ matrix_new2
        self.arithmetic_sequence_info('#内积运算 matrix_new1 @ matrix_new2', matrix_new)
        self.arithmetic_sequence_info('#内积运算 np.dot(matrix_new1 , matrix_new2)', np.dot(matrix_new1 , matrix_new2))

        # 生成一个一维序列数组
        tmp_array3 = np.linspace(start=1, stop=3, num=6)
        matrix_new3 = tmp_array3.reshape(2, 3)
        self.arithmetic_sequence_info('matrix_new3', matrix_new3)

        # np.round(x, 2)  # 每一个特征保留小数位  #四舍五入
        print(f'np.round(matrix_new3 , 2)={np.round(matrix_new3, 2)}')
        # np.max(x)#所有最大值
        print(f'np.max(matrix_new3)={np.max(matrix_new3)}')
        # np.max(x , axis = 0)  #每一个特征的最大值，指定某一列(每列的最大)
        print(f'np.max(matrix_new3 , axis=0)={np.max(matrix_new3, axis=0)}')
        # np.min(x , axis = 0) #每一个特征的最小值，指定某一列(每列的最小)
        print(f'np.min(matrix_new3 , axis=0)={np.min(matrix_new3, axis=0)}')
        # np.mean(x , axis = 0) #每一个特征的平均值，指定某一列(每列的平均值)
        print(f'np.mean(matrix_new3 , axis=0)={np.mean(matrix_new3, axis=0)}')
        # np.sum(x , axis = 0) #每一个特征的求和，指定某一列（每列的求和）
        print(f'np.sum(matrix_new3 , axis=0)={np.sum(matrix_new3, axis=0)}')
        #方差计算 np.var(x , axis = 0)
        print(f'方差计算 np.var(matrix_new3 , axis = 0)={np.var(matrix_new3, axis = 0)}')
        #标准差 np.std(x , axis = 0)
        print(f'标准差 np.std(matrix_new3 , axis = 0)={np.std(matrix_new3, axis=0)}')


#输出到日志文件
#logging.basicConfig(filename='my_log.log' ,level=logging.DEBUG, format='%(asctime)s --- %(levelname)s: %(message)s',datefmt='%Y/%m/%d %H:%M:%S')
#logging.info("111")
obj = Practice0812('test' , 10000 , 100)
#obj.create_arithmetic_sequence()
# obj.create_arithmetic_sequence2()
#obj.create_arithmetic_sequence3()
# obj.create_arithmetic_sequence4()
obj.create_other()
# obj.print_array2_slice()
# obj.cal_array2()